Robust Mesh Segmentation Using Feature-Aware Region Fusion

This paper introduces a simple but powerful segmentation algorithm for 3D meshes. Our algorithm consists of two stages: over-segmentation and region fusion. In the first stage, adaptive space partition is applied to perform over-segmentation, which is very efficient. In the second stage, we define a new intra-region difference, inter-region difference, and fusion condition with the help of various shape features and propose an iterative region fusion method. As the region fusion process is feature aware, our algorithm can deal with complex 3D meshes robustly. Massive qualitative and quantitative experiments also validate the advantages of the proposed algorithm.


Introduction
In computer vision, computer graphics, and multimedia processing, the segmentation of 3D meshes is a popular but difficult research topic. As an important operation, mesh segmentation is helpful for conducting 3D analysis and developing our understanding, and can be applied to various subsequent operations. For example, segmentation results can provide semantic information for high-level feature extraction. Moreover, the user can first segment a variety of 3D meshes. Then, some mesh parts from different meshes can be composed to generate new 3D meshes. Therefore, the accuracy and robustness of segmentation algorithms are indispensable.
The purpose of mesh segmentation is to decompose an input 3D mesh into multiple semantic parts. The key is how to make full use of its shape features to obtain a perceptionaware segmentation result. Three-dimensional meshes often have complex shapes or rich details, which makes mesh segmentation very challenging. Many works focus on automatic segmentation algorithms [1][2][3]. Interactive segmentation algorithms [4,5] guide the segmentation process through user-specified strokes. In recent years, data-driven methods have been used to deal with the mesh segmentation problem [6][7][8]. In particular, deep learning techniques have been employed to enhance the generalization ability [9][10][11][12]. However, segmentation accuracy still needs to be improved for practical applications.
To address the mesh segmentation problem robustly, we developed a feature-aware algorithm that utilizes various shape features of 3D meshes and can obtain perceptionaware results efficiently. Figure 1 shows the overview of the algorithm conducted on a mesh with a complex shape and rich details. The input mesh is large and the segmentation run-time depends nonlinearly on mesh size, as an input mesh may have millions of facets. Therefore, we group input facets into collections of contiguous mesh facets; each collection is called a superfacet. There are about 40× fewer superfacets than input facets; thus, we perform segmentation on these superfacets for a speed up to about 100×. Therefore, we group input facets into collections of contiguous mesh facets; each collection is called a superfacet. There are about 40× fewer superfacets than input facets; thus, we perform segmentation on these superfacets for a speed up to about 100×. Figure 1. Algorithm overview conducted on an armadillo mesh [6]. Firstly, we perform a rapid oversegmentation using the adaptive space partition to yield a set of superfacets. Secondly, we use a feature-aware region fusion method to merge similar superfacets to generate the final segmentation result. For demonstration, all superfacets and segmentation parts are rendered with random colors.
Then, a variety of shape features are calculated to represent local attributes of superfacets, such as normal, Gaussian curvature [13], shape diameter function [14], average geodesic distance [15], conformal factor [16], and heat kernel signature [17] attributes. We further introduce an intra-region difference, inter-region difference, and fusion condition, and iteratively fuse neighboring superfacets with similar attributes to generate a segmentation result.
In order to validate the effectiveness and robustness of our algorithm, segmentation experiments are conducted on a large number of 3D meshes with complex shapes or rich details. Even if Gaussian noises, holes, missing parts, pose changes, or sampling changes appear on the 3D meshes, our algorithm can still obtain visually pleasing results. Therefore, we can qualitatively and quantitatively compare it with many state-of-the-art methods. Quantitative metrics for the evaluation of the segmentation results include accuracy, Rand Index, Cut Discrepancy, Consistency Error, and Hamming Distance. All the comparisons demonstrate the advantages of our algorithm. The proposed algorithm has several parameters. We tune them manually to obtain the best result.
The main contributions of this paper can be summarized by the following two points: 1. An efficient over-segmentation method is introduced via adaptive space partition. 2. By defining a new intra-region difference, inter-region difference, and fusion condition, a simple but powerful feature-aware region fusion algorithm is proposed that can robustly achieve mesh segmentation.

Related Work
Many automatic segmentation algorithms have been proposed. Chazelle et al. [18] presented a method for decomposing a polygonal surface using a flooding heuristic. Zhou and Huang [19] decomposed a polygon mesh into meaningful parts or regions by means of critical points. Katz et al. [1] addressed mesh segmentation through fuzzy clustering and graph cuts. Lavoue and Wolf [20] presented a mesh segmentation method based on Markov random fields. Golovinskiy et al. [21] adopted randomized cuts for mesh segmentation and analysis. A 3D mesh segmentation benchmark, proposed by Chen et al. [22], can analyze and compare different segmentation algorithms quantitatively. Au et al. [2] introduced a mesh segmentation algorithm using concavity-sensitive scalar fields. Theologou et al. [23] constructed a heterogeneous graph containing local features and patch affinities and performed spectral partitioning with the help of nodal set and nodal domain theory. Zhang et al. [24] obtained their initial result via spectral clustering, and then  [6]. Firstly, we perform a rapid over-segmentation using the adaptive space partition to yield a set of superfacets. Secondly, we use a feature-aware region fusion method to merge similar superfacets to generate the final segmentation result. For demonstration, all superfacets and segmentation parts are rendered with random colors.
Then, a variety of shape features are calculated to represent local attributes of superfacets, such as normal, Gaussian curvature [13], shape diameter function [14], average geodesic distance [15], conformal factor [16], and heat kernel signature [17] attributes. We further introduce an intra-region difference, inter-region difference, and fusion condition, and iteratively fuse neighboring superfacets with similar attributes to generate a segmentation result.
In order to validate the effectiveness and robustness of our algorithm, segmentation experiments are conducted on a large number of 3D meshes with complex shapes or rich details. Even if Gaussian noises, holes, missing parts, pose changes, or sampling changes appear on the 3D meshes, our algorithm can still obtain visually pleasing results. Therefore, we can qualitatively and quantitatively compare it with many state-of-the-art methods. Quantitative metrics for the evaluation of the segmentation results include accuracy, Rand Index, Cut Discrepancy, Consistency Error, and Hamming Distance. All the comparisons demonstrate the advantages of our algorithm. The proposed algorithm has several parameters. We tune them manually to obtain the best result.
The main contributions of this paper can be summarized by the following two points: 1.
An efficient over-segmentation method is introduced via adaptive space partition.

2.
By defining a new intra-region difference, inter-region difference, and fusion condition, a simple but powerful feature-aware region fusion algorithm is proposed that can robustly achieve mesh segmentation.

Related Work
Many automatic segmentation algorithms have been proposed. Chazelle et al. [18] presented a method for decomposing a polygonal surface using a flooding heuristic. Zhou and Huang [19] decomposed a polygon mesh into meaningful parts or regions by means of critical points. Katz et al. [1] addressed mesh segmentation through fuzzy clustering and graph cuts. Lavoue and Wolf [20] presented a mesh segmentation method based on Markov random fields. Golovinskiy et al. [21] adopted randomized cuts for mesh segmentation and analysis. A 3D mesh segmentation benchmark, proposed by Chen et al. [22], can analyze and compare different segmentation algorithms quantitatively. Au et al. [2] introduced a mesh segmentation algorithm using concavity-sensitive scalar fields. Theologou et al. [23] constructed a heterogeneous graph containing local features and patch affinities and performed spectral partitioning with the help of nodal set and nodal domain theory. Zhang et al. [24] obtained their initial result via spectral clustering, and then discretized the Mumford-Shah model for further refining. Tong et al. [3] formulated mesh segmentation as a L 0 optimization problem with respect to the Fiedler vector. Zhang et al. [25] segmented a mesh by blending regions into different patches and fitted each patch through a surface primitive. Lin et al. [26] performed segmentation based on a medial axis transform, which encodes both geometrical and structural information.
Interactive segmentation algorithms are employed to reflect user intentions. Ji et al. [4] drew a foreground stroke and a background stroke on the mesh model for guidance. Then, the segmentation result can be generated via region growth. Later on, various interaction tools were presented. Zheng et al. [27] introduced cross-boundary strokes to identify the desired cut. Fan et al. [28] only specified a stroke on the foreground region. Zheng et al. [5] only needed to draw a boundary point. Further, Hou et al. [29] combined random walks with the L 0 constraint to locate segmentation boundaries.
Recently, data-driven methods have been adopted to deal with the segmentation problem. Based on some labeled meshes, Kalogerakis et al. [6] applied a conditional random field model to learn the segmentation results. Benhabiles et al. [7] used the AdaBoost classifier to learn the boundaries between mesh parts. Wang et al. [8] projected a 3D model onto a set of binary images, found the initial labels in a labeled image set, and optimized them by using the graph cut method.
Subsequently, deep neural networks can be utilized to improve the generalization ability. Guo et al. [9] organized mesh features into 2D matrices and used these data as the input of the network to learn the facets' labels. George et al. [12] and Shu et al. [30] used feature vectors as the network input to reduce the mutual influence among different features. Taking multi-view rendered images and depth images as the input, Kalogerakis et al. [10] trained convolutional neural networks and a conditional random field in an endto-end way. To handle the unstructured sampling of mesh models, Xu et al. [11] defined rotation-invariant convolution and pooling operations. Yi et al. [31] generated segmentation results by combining the neural network and spectral analysis. Wang et al. [32] investigated the segmentation problem by using volumetric representation and proposed a voxel-based feature extraction module and an attention-based feature aggregation module. Hu et al. [33] operated on both voxels and a mesh surface to incorporate Euclidean information and geodesic information. Additionally, weakly supervised and semi-supervised schemes were employed to reduce the requirements of the training data [34,35].
Some segmentation methods were designed for medical treatment. Xu et al. [36] aimed to cut out each tooth in a 3D dental model. Lawonn et al. [37] performed segmentation on the 3D surfaces of vessels and then identified aneurysms. As an extension, the segmentation of point clouds has drawn a lot of attention. For example, Wang et al. [38] introduced a similarity group proposal network for instance segmentation on point clouds. Furthermore, the segmentation problem is closely related to many other 3D processing problems, such as object classification [39], shape unfolding [40], and surface denoising [41,42].
Our main idea was published during the CDMMS2020 [43]. This paper presents substantial improvements over the previous short conference version in both the algorithm and experiments. Generally, we improve our algorithm (e.g., the intra-region difference, the inter-region difference, and the threshold function), and provide further analysis and discussion, which explains why the proposed algorithm works well. Firstly, the intra-region difference is defined as the maximum of the differences between adjacent superfacets in [43]. As the maximum would overestimate the difference, we adopt the average in this paper. Secondly, the inter-region difference is defined as the minimum of the differences at the boundary in [43]. Considering that the minimum would underestimate the difference, we also adopt the average in this paper. By contrast, our new definitions are more reasonable and more effective for handling different kinds of 3D meshes. Thirdly, the threshold function is based on the formulation of 1 x in [43]. We adopt the formulation of 1 e x in this paper. As proved by the existing algorithms of [29,44,45], the formulation of 1 e x is more flexible when dealing with complex cases. Additionally, in our prior paper [43], we only conducted limited segmentation experiments. In this paper, we provide comprehensive segmentation results, and further evaluate the robustness in regard to Gaussian noises, holes, missing parts, pose changes, and sampling changes. We also compare our algorithm with existing state-of-the-art algorithms qualitatively and quantitatively to show our advantages, and then demonstrate its high-time performance.

Feature-Aware Mesh Segmentation Algorithm
A 3D mesh consists of mesh vertices and triangular facets. Each mesh vertex has a 3D position. Three vertices form a triangular facet. In this section, we will elaborate the proposed segmentation algorithm, including the binary space partition and feature-aware region fusion.

Efficient Adaptive Space Partition
Three-dimensional meshes usually contain a large number of triangular facets, and exhibit complex shapes or rich details. If the segmentation is performed on triangular facets, it would lead to a low-time performance. Hence, binary space partition [46] is adopted to split a 3D mesh into a set of superfacets, which could reduce computational costs and improve time performance. Suppose p i (1 ≤ i ≤ k) is a mesh vertex, and k is the number of vertices in the current partition space; then, the 3 × 3 covariance matrix can be expressed as: where p is the centroid of all vertices in the current partition space.
The eigen equation of C can be expressed as: , λ l is an eigenvalue, and v l is an eigenvector. λ l is a good measure of the variation in the mesh along the direction of v l . Assuming λ 0 ≤ λ 1 ≤ λ 2 , according to [46], the surface variation is defined as follows: Closely related to the mean curvature, this surface variation can effectively estimate the characteristics of the mesh.
The partition plane is defined as follows: where v 0 is the corresponding eigenvector of λ 0 . In other words, we always partition the mesh model along the direction of the greatest variation. In practice, we perform binary space partition recursively. Each partitioned subspace should be further partitioned until its number of triangular facets is less than the threshold q max and its surface variation is less than the threshold σ max . When this process is finished, the triangular facets in each partitioned subspace are treated as a superfacet. Please note that the number of superfacets is far less than that of triangular facets. We denote the set of superfacets as F = {F i , 1 ≤ i ≤ |F|}, where F i is a superfacet, and |F| is the number of superfacets. Figure 2 shows an example of over-segmentation. The horse model has 48,485 vertices and 96,966 facets. Due to the high efficiency of binary space partition, it only takes 0.094 s to complete the over-segmentation. This example produces 1218 superfacets. Thus, performing segmentation on superfacets greatly reduces computational cost and improves time efficiency. Previous methods pay little attention to over-segmentation, and fulfill this task via existing segmentation algorithms. Algorithm parameters are tuned to generate superfacets rather than mesh parts. However, over-segmentation is very important for mesh segmentation. We introduce a very efficient over-segmentation scheme through adaptive space partition.

Feature Description
We can describe local mesh attributes via various shape features. For example, normal, Gaussian curvature [13], shape diameter function [14], average geodesic distance [15], conformal factor [16], and heat kernel signature [17]. These shape features are computed for each superfacet . As the above features have different scales, we first normalize each shape feature separately, and then concatenate them to form a feature vector ( ) for superfacet . We further define the difference between adjacent superfacets and as follows: where ‖•‖ 2 is the L2 norm. In other words, the difference is the Euclidean distance between feature vectors.

Region Fusion
Initially, each superfacet represents a local region. Region fusion is an intuitive method that fuses these regions together to obtain the final segmentation result. Two adjacent regions have similar attributes and should belong to the same part of the model if their difference is relatively small. Under this condition, we fuse them into one region. In the following, we elaborate our intra-region difference, inter-region difference, fusion condition, and fusion process.
Suppose is a local region that consists of several superfacets. Its intra-region difference is defined as the average of the differences between adjacent superfacets. That is, where and are two adjacent superfacets in . Our prior paper [43] used the maximum, which would overestimate the difference. Obviously, this new definition can reflect surface changes in more effectively.
Suppose 1 and 2 are two adjacent regions. We define their inter-region difference as the average of the differences at the boundary: Previous methods pay little attention to over-segmentation, and fulfill this task via existing segmentation algorithms. Algorithm parameters are tuned to generate superfacets rather than mesh parts. However, over-segmentation is very important for mesh segmentation. We introduce a very efficient over-segmentation scheme through adaptive space partition.

Feature Description
We can describe local mesh attributes via various shape features. For example, normal, Gaussian curvature [13], shape diameter function [14], average geodesic distance [15], conformal factor [16], and heat kernel signature [17]. These shape features are computed for each superfacet F i . As the above features have different scales, we first normalize each shape feature separately, and then concatenate them to form a feature vector T(F i ) for superfacet F i . We further define the difference between adjacent superfacets F i and F j as follows: where · 2 is the L 2 norm. In other words, the difference is the Euclidean distance between feature vectors.

Region Fusion
Initially, each superfacet represents a local region. Region fusion is an intuitive method that fuses these regions together to obtain the final segmentation result. Two adjacent regions have similar attributes and should belong to the same part of the model if their difference is relatively small. Under this condition, we fuse them into one region. In the following, we elaborate our intra-region difference, inter-region difference, fusion condition, and fusion process.
Suppose R is a local region that consists of several superfacets. Its intra-region difference is defined as the average of the differences between adjacent superfacets. That is, where F i and F j are two adjacent superfacets in R. Our prior paper [43] used the maximum, which would overestimate the difference. Obviously, this new definition can reflect surface changes in R more effectively. Suppose R 1 and R 2 are two adjacent regions. We define their inter-region difference as the average of the differences at the boundary: where F i and F j are two adjacent superfacets from R 1 and R 2 , respectively. Our prior paper [43] used the minimum, which would underestimate the difference. In contrast, this new definition is more reasonable for measuring geometric changes between R 1 and R 2 . Two adjacent regions can be fused into a new region if their inter-region difference is less than the minimum value of their intra-region differences. We formulate this fusion condition as: where D(R 1 ) and D(R 2 ) are the intra-region differences of R 1 and R 2 , respectively, and t(·) is a threshold function with respect to local regions. t(·) is used to adjust the above fusion condition. Initially, each local region contains only one superfacet; thus, D(R 1 ) = 0, and D(R 2 ) = 0. The fusion process would fail to start if there is no t(·) in Equation (4).
When there are fewer superfacets in the region, t(·) should have a relatively large value to relax the fusion condition. When the regions contain more superfacets due to fusing, t(·) should be closer to 0 and should have little effect on the fusion process. Therefore, t(·) should be a decreasing function, which decreases as the number of superfacets in the region increases. As proved by the existing algorithms of [29,44,45], the formulation of 1 e x works well in practice. In this paper, our threshold function is defined as: where |R| is the number of superfacets in the local region R, and m is a constant. The prior threshold function is based on the formulation of 1 x in [43]. In comparison, the new threshold function is more flexible for handling complex cases.
All inter-region differences of the adjacent regions are sorted from small to large. Then, the fusion is performed according to this order. After the two regions are fused, we update their intra-region differences and inter-region differences with other adjacent regions. This fusion process will only stop if all adjacent regions fail to meet the fusion condition

Boundary Smoothing
When the above fusion is finished, if a region contains few superfacets, we will merge it into an adjacent region with the smallest inter-region difference. Furthermore, there might be jaggy boundaries between adjacent regions. The graph cut algorithm [47] is applied to smooth these boundaries. Without a loss of generality, we discuss this process between two adjacent regions, R 1 and R 2 . We grow a narrow fuzzy region S from their current boundary. Those facets that directly connect to R 1 or R 2 are collected as set M or set N , respectively. For any facet f i in S, its unit normal and local neighborhood are denoted as n f i and N i , respectively. Additionally, we use R f i to represent which region f i belongs to. In other words, R f i should be either R 1 or R 2 .
The graph cut algorithm needs to optimize an energy function consisting of a data term and a regularization term. The data term is defined as: 1, i f R f i con f licts with M and N 0, otherwise . The regularization term is defined as: i −n f j 2 , n f j is the unit normal of f j , and R f j represents which region f j belongs to. w ij describes the similarity between f i and f j . The larger it is, the more likely it is that f i and f j should belong to the same region. As shown in the close-up views in Figure 3, this scheme is able to smooth region boundaries.  Finally, each region forms a segmentation part of the mesh. Figure 4 shows the segmentation process of our algorithm. First, adaptive space partition is used to obtain an over-segmentation result. Then, regions that meet the fusion condition are iteratively merged to obtain the final segmentation result.

Results and Analysis
We implemented our algorithm by using C++ on a computer with an Intel Core i5-5200U CPU. There are three parameters of this algorithm: { , , m}. The parameters and are used to control over-segmentation. Here, ∈ [10,80]. The default value for is 0.1. The parameter is used to adjust (⋅) to control the fusion condition, and ∈ [2,12]. The segmentation experiments were performed on a large number of 3D meshes, some of which have Gaussian noises, holes, missing parts, pose changes, or sampling changes. In addition, we also made qualitative and quantitative comparisons with some previous state-of-the-art methods. All these results validate the advantages of the proposed algorithm. Figure 5 demonstrates some segmentation results from the different kinds of 3D meshes, such as a bird, armadillo, horse, cup, hand, teddy, and octopus. Each mesh has a complex shape and specific semantics. It is difficult to work well on all of them. Our algorithm utilizes various shape features effectively and fuses neighboring regions with similar attributes to yield satisfactory results. Finally, each region forms a segmentation part of the mesh. Figure 4 shows the segmentation process of our algorithm. First, adaptive space partition is used to obtain an over-segmentation result. Then, regions that meet the fusion condition are iteratively merged to obtain the final segmentation result.  Finally, each region forms a segmentation part of the mesh. Figure 4 shows the segmentation process of our algorithm. First, adaptive space partition is used to obtain an over-segmentation result. Then, regions that meet the fusion condition are iteratively merged to obtain the final segmentation result.

Results and Analysis
We implemented our algorithm by using C++ on a computer with an Intel Core i5-5200U CPU. There are three parameters of this algorithm: { , , m}. The parameters and are used to control over-segmentation. Here, ∈ [10,80]. The default value for is 0.1. The parameter is used to adjust (⋅) to control the fusion condition, and ∈ [2,12]. The segmentation experiments were performed on a large number of 3D meshes, some of which have Gaussian noises, holes, missing parts, pose changes, or sampling changes. In addition, we also made qualitative and quantitative comparisons with some previous state-of-the-art methods. All these results validate the advantages of the proposed algorithm. Figure 5 demonstrates some segmentation results from the different kinds of 3D meshes, such as a bird, armadillo, horse, cup, hand, teddy, and octopus. Each mesh has a complex shape and specific semantics. It is difficult to work well on all of them. Our algorithm utilizes various shape features effectively and fuses neighboring regions with similar attributes to yield satisfactory results.

Results and Analysis
We implemented our algorithm by using C++ on a computer with an Intel Core i5-5200U CPU. There are three parameters of this algorithm: {q max , σ max , m}. The parameters q max and σ max are used to control over-segmentation. Here, q max ∈ [10,80]. The default value for σ max is 0.1. The parameter m is used to adjust t(·) to control the fusion condition, and m ∈ [2,12]. The segmentation experiments were performed on a large number of 3D meshes, some of which have Gaussian noises, holes, missing parts, pose changes, or sampling changes. In addition, we also made qualitative and quantitative comparisons with some previous state-of-the-art methods. All these results validate the advantages of the proposed algorithm. Figure 5 demonstrates some segmentation results from the different kinds of 3D meshes, such as a bird, armadillo, horse, cup, hand, teddy, and octopus. Each mesh has a complex shape and specific semantics. It is difficult to work well on all of them. Our algorithm utilizes various shape features effectively and fuses neighboring regions with similar attributes to yield satisfactory results.

Robustness Evaluations
In this paper, we define the reasonable intra-region difference, inter-region difference, and fusion condition, which are effective and robust. The robustness can be validated by testing meshes with Gaussian noises, holes, missing parts, pose changes, and sampling changes. In Figure 6, we added Gaussian noises to a goblet mesh along normal directions and random directions, respectively. The intensities are 0.3, 0.4, and 0.5. Noise affects the local shape features, and makes mesh segmentation more challenging. Our region fusion method is flexible in dealing with different noises. Therefore, the six results are ideal and consistent with each other. Figure 7 shows the segmentation results for bird and donkey meshes with holes. Each model has many holes of different sizes. In other words, each model has a lot of missing data. The proposed algorithm makes full use of the shape features and can obtain perception-aware results.

Robustness Evaluations
In this paper, we define the reasonable intra-region difference, inter-region difference, and fusion condition, which are effective and robust. The robustness can be validated by testing meshes with Gaussian noises, holes, missing parts, pose changes, and sampling changes. In Figure 6, we added Gaussian noises to a goblet mesh along normal directions and random directions, respectively. The intensities are 0.3, 0.4, and 0.5. Noise affects the local shape features, and makes mesh segmentation more challenging. Our region fusion method is flexible in dealing with different noises. Therefore, the six results are ideal and consistent with each other. Figure 7 shows the segmentation results for bird and donkey meshes with holes. Each model has many holes of different sizes. In other words, each model has a lot of missing data. The proposed algorithm makes full use of the shape features and can obtain perception-aware results.

Robustness Evaluations
In this paper, we define the reasonable intra-region difference, inter-region difference, and fusion condition, which are effective and robust. The robustness can be validated by testing meshes with Gaussian noises, holes, missing parts, pose changes, and sampling changes. In Figure 6, we added Gaussian noises to a goblet mesh along normal directions and random directions, respectively. The intensities are 0.3, 0.4, and 0.5. Noise affects the local shape features, and makes mesh segmentation more challenging. Our region fusion method is flexible in dealing with different noises. Therefore, the six results are ideal and consistent with each other. Figure 7 shows the segmentation results for bird and donkey meshes with holes. Each model has many holes of different sizes. In other words, each model has a lot of missing data. The proposed algorithm makes full use of the shape features and can obtain perception-aware results.    Figure 8 shows the segmentation results of glasses meshes with missing parts. A hough these models are missing different parts, our algorithm can still generate results complying with semantics. Figure 9 demonstrates the segmentation results of ted  Figure 8 shows the segmentation results of glasses meshes with missing parts. Although these models are missing different parts, our algorithm can still generate results by complying with semantics. Figure 9 demonstrates the segmentation results of teddy meshes in different poses. This algorithm is oblivious to pose changes, and thus, locates stable segmentation boundaries. In Figure 10, we exhibit the results of airplane meshes with different samplings. Our algorithm is not affected by sampling changes. No matter if the sampling is high or low, these segmentation results are consistent with each other.
PEER REVIEW 9 of 15 meshes in different poses. This algorithm is oblivious to pose changes, and thus, locates stable segmentation boundaries. In Figure 10, we exhibit the results of airplane meshes with different samplings. Our algorithm is not affected by sampling changes. No matter if the sampling is high or low, these segmentation results are consistent with each other.

Qualitative and Quantitative Comparisons
Figure 11 compares our algorithm with the automatic segmentation algorithm [2], which depends on the Gaussian curvature and shape concavity. When a mesh model has too many concave creases, redundant cuts occur [2]. Our algorithm fuses local regions of the same part to obtain a better result. Figure 12 shows a comparison between our algorithm and the deep learning segmentation algorithm [10], which utilizes convolutional neural networks and a conditional random field. However, [10] is not robust to noise, thus producing wrong segmentation boundaries. In contrast, our algorithm obtains accurate boundaries.  Figure 11 compares our algorithm with the automatic segmentation algorithm [2], which depends on the Gaussian curvature and shape concavity. When a mesh model has too many concave creases, redundant cuts occur [2]. Our algorithm fuses local regions of the same part to obtain a better result. Figure 12 shows a comparison between our algorithm and the deep learning segmentation algorithm [10], which utilizes convolutional neural networks and a conditional random field. However, [10] is not robust to noise, thus producing wrong segmentation boundaries. In contrast, our algorithm obtains accurate boundaries. Quantitative comparisons are also very important. The most intuitive metric is segmentation accuracy, which is defined as the percentage of correctly labeled facets according to ground truth data. Table 1 demonstrates the accuracy comparisons with datadriven segmentation algorithms of [6,9,10,12]. In particular, the algorithms of [9,10,12] are based on deep learning. Data-driven algorithms, especially deep learning ones, are dependent on having a large amount of labeled training data. In practice, their generaliza- Quantitative comparisons are also very important. The most intuitive metric is segmentation accuracy, which is defined as the percentage of correctly labeled facets according to ground truth data. Table 1 demonstrates the accuracy comparisons with datadriven segmentation algorithms of [6,9,10,12]. In particular, the algorithms of [9,10,12] are based on deep learning. Data-driven algorithms, especially deep learning ones, are de- Quantitative comparisons are also very important. The most intuitive metric is segmentation accuracy, which is defined as the percentage of correctly labeled facets according to ground truth data. Table 1 demonstrates the accuracy comparisons with data-driven segmentation algorithms of [6,9,10,12]. In particular, the algorithms of [9, 10,12] are based on deep learning. Data-driven algorithms, especially deep learning ones, are dependent on having a large amount of labeled training data. In practice, their generalization ability and robustness are their bottlenecks. In contrast, our algorithm (i.e., adaptive space partition and iterative region fusion) does not need any training data and is flexible and robust when handling various 3D meshes and complex cases. Therefore, our accuracy is apparently higher than those of [6,9,10,12]. Table 1. Accuracy comparisons with data-driven segmentation algorithms [6,9,10,12]. Please note that, higher values indicate better results.

Ours
Shapeboost Chen et al. [22] introduced several metrics for the evaluation of mesh segmentation methods: Rand Index, Cut Discrepancy, Consistency Error, and Hamming Distance. In Figure 13, we further compare our algorithm with five state-of-the-art algorithms quantitatively: ShapeDiam [14], CoreExtra [48], RandWalks [49], FitPrim [50], and KMeans [51]. Our results obtained lower values under these metrics. In other words, our algorithm is superior to these state-of-the-art algorithms.

Further Discussions and Time Performance
As with most segmentation methods, the parameters should be adjusted manually for different meshes. In this paper, and affect over-segmentation, and m affects the fusion condition. We fine-tune these parameters to obtain the best result. Figure  14 demonstrates the segmentation results using different parameters. When m is too

Further Discussions and Time Performance
As with most segmentation methods, the parameters should be adjusted manually for different meshes. In this paper, q max and σ max affect over-segmentation, and m affects the fusion condition. We fine-tune these parameters to obtain the best result. Figure 14 demonstrates the segmentation results using different parameters. When m is too small, some regions fail to merge together, thus resulting in apparent errors.
(c) (d) Figure 13. Quantitative comparisons with five state-of-the-art segmentation algorithms of [14,[48][49][50][51]. RI is Rand Index, CD is Cut Discrepancy, GCE is Global Consistency Error, LCE is Local Consistency Error, Hamming is Hamming Distance, Hamming-Rm is missing rate, and Hamming-Rf is false alarm rate. Please note that lower values indicate better results.

Further Discussions and Time Performance
As with most segmentation methods, the parameters should be adjusted manually for different meshes. In this paper, and affect over-segmentation, and m affects the fusion condition. We fine-tune these parameters to obtain the best result. Figure  14 demonstrates the segmentation results using different parameters. When m is too small, some regions fail to merge together, thus resulting in apparent errors.  Our algorithm has substantial improvements over the prior one [43]. We define a new intra-region difference, inter-region difference, and threshold function, which are more reasonable and more flexible for handling different meshes and complex cases. In our prior paper [43], we may have overestimated the difference within a region, and underestimated the difference between adjacent regions. Figure 15 shows a comparison using an incomplete vase mesh that is hard to segment. Some regions belonging to the top part, the handle part, and the base part are fused into the cup part in the result of [43]. Our result looks natural.

2023, 23, x FOR PEER REVIEW 12 of 15
Our algorithm has substantial improvements over the prior one [43]. We define a new intra-region difference, inter-region difference, and threshold function, which are more reasonable and more flexible for handling different meshes and complex cases. In our prior paper [43], we may have overestimated the difference within a region, and underestimated the difference between adjacent regions. Figure 15 shows a comparison using an incomplete vase mesh that is hard to segment. Some regions belonging to the top part, the handle part, and the base part are fused into the cup part in the result of [43]. Our result looks natural.
(a) (b) Figure 15. Comparison with our prior paper [43] carried out on an incomplete vase mesh. Please note that [43] generates wrong segmentation boundaries. (a) Our result. (b) Result of [43]. Table 2 lists time statistics for some mesh models. The performance depends on several factors, such as the number of facets, the number of superfacets,, etc. Overall, our algorithm is very efficient due to binary space partition and region fusion.   Table 2 lists time statistics for some mesh models. The performance depends on several factors, such as the number of facets, the number of superfacets, etc. Overall, our algorithm is very efficient due to binary space partition and region fusion.